/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package starfox.personagens;

import java.util.ArrayList;
import java.util.Iterator;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Image;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.Sound;
import org.newdawn.slick.geom.Vector2f;
import util.CaixaColisao;
import util.StopWatch;

/**
 *
 * @author Lucas
 */
public class Arwing {
    //Sprites
    Image[] sprite = new Image[6];
    //Posição
    Vector2f pos = new Vector2f();
    //Status da nave, para definir qual sprite usar
    int status;

    //Número de vidas
    int vidas;

    //Verificar se a nave pode levar tiro ou não (dar um tempo de recuperação após tomar um tiro)
    boolean collidable;

    //Verificar o tempo depois que a nave levou um tiro para poder levar outro tiro
    StopWatch tempoMorto = null;

    //Tiros
    ArrayList<TiroPersonagem> tiros = null;

    //Tiro temporário, para ser adicionado à ArrayList
    TiroPersonagem tiro;

    //Caixa de colisão
    CaixaColisao box = null;

    //Som de tiro
    Sound shoot = null;

    //Atributo para pegar as teclas pressionadas
    Input input = null;
    
    //Pontuação
    int pontuacao;

    public Arwing() throws SlickException {
        //Coloca como padrão o sprite 0
        status = 0;
        
        //Coloca a pontuação inicial como 0
        pontuacao = 0;

        /*Carrega os 6 sprites da imagem. Os 3 primeiros são os padrões, os outros 3
         * são transparentes e usados após a nave tomar um tiro.
         */
        for(int i=0; i<6; i++)
        {
            sprite[i] = new Image("imagens/sprites/"+i+".png");
        }

        //Coloca a posição no meio da tela
        pos.x = 400-sprite[status].getWidth()/2;
        pos.y = 300-sprite[status].getHeight()/2;

        vidas = 5;
        collidable = true;
        tempoMorto = new StopWatch();

        tiros = new ArrayList<TiroPersonagem>();
        shoot = new Sound("music/arwingPulseLaser.ogg");

        //Colocar a caixa de colisão em torno do "corpo" da nave
        box = new CaixaColisao(pos.x+38, pos.y, 42, sprite[status].getHeight());
    }

    public void render() {
        //Desenha a nave de acordo com o status
        sprite[status].draw(pos.x, pos.y);

        //Desenha os tiros da nave, se houver algum
        for(TiroPersonagem t : tiros)
                t.render();
    }

    public ArrayList<TiroPersonagem> getTiros(){
        return tiros;
    }

    public CaixaColisao getCaixaColisao(){
        return box;
    }

    public boolean isCollidable(){
        return collidable;
    }

    public void diminuiVidas(){
        if(vidas > 0) vidas--;
    }

    public int getVidas(){
        return vidas;
    }

    public void setCollidable(boolean collidable){
        this.collidable = collidable;
    }

    public int getWidth(){
        return sprite[status].getWidth();
    }

    public int getHeight(){
        return sprite[status].getHeight();
    }

    public Vector2f getPos(){
        return pos;
    }
    
    public void aumentarPontuacao(int pontos){
        this.pontuacao += pontos;
    }
    
    public int getPontuacao(){
        return pontuacao;
    }

    public void update(GameContainer gc, int delta) throws SlickException {
        input = gc.getInput();

        //Mover a nave, mantendo a velocidade caso ela esteja na diagonal.
        if(input.isKeyDown(Input.KEY_UP)) {
            if(pos.y >= 0)
                if(input.isKeyDown(Input.KEY_RIGHT) || input.isKeyDown(Input.KEY_LEFT))
                    pos.y -= 0.71f*0.3f*delta;
                else
                    pos.y -= 0.3f*delta;
        }
        if(input.isKeyDown(Input.KEY_DOWN)) {
            if(pos.y <= (600-sprite[status].getHeight()))
                if(input.isKeyDown(Input.KEY_RIGHT) || input.isKeyDown(Input.KEY_LEFT))
                    pos.y += 0.71f*0.3f*delta;
                else
                    pos.y += 0.3f*delta;
        }
        /*Se a nave estiver indo para os lados, trocar
         * o sprite (status) dela por um que está virando.
         */
        if(input.isKeyDown(Input.KEY_LEFT)) {
            if(collidable) status = 1;
            else status = 4;

            if(pos.x >= 0)
                if(input.isKeyDown(Input.KEY_UP) || input.isKeyDown(Input.KEY_DOWN))
                    pos.x -= 0.71f*0.3f*delta;
                else
                    pos.x -= 0.3f*delta;
        }
        if(input.isKeyDown(Input.KEY_RIGHT)) {
            if(collidable) status = 2;
            else status = 5;

            if(pos.x <= (800-sprite[status].getWidth()))
                if(input.isKeyDown(Input.KEY_UP) || input.isKeyDown(Input.KEY_DOWN))
                    pos.x += 0.71f*0.3f*delta;
                else
                    pos.x += 0.3f*delta;
        }
        if(!(input.isKeyDown(Input.KEY_RIGHT)) && !(input.isKeyDown(Input.KEY_LEFT))){
            if(collidable) status = 0;
            else status = 3;
        }

        //Atualizar a posição da caixa de colisão
        box.update(pos.x+38, pos.y);

        //Esperar 3 segundos após tomar um tiro para poder tomar outro
        if(!collidable){
            if(!tempoMorto.isRunning()) tempoMorto.start();
            if(tempoMorto.getElapsedTimeSecs() >= 3){
                collidable = true;
                tempoMorto.stop();
                tempoMorto.reset();
            }
        }

        /*Atirar. Essa ação consiste em criar um novo Tiro e adicioná-lo
             * a um ArrayList de tiros. Então, usa-se um iterador para percorrer
             * o ArrayList, fazendo com que cada tiro seja atualizado (suba na tela)
             * e removendo-o caso esteja em uma posição inválida (fora da tela).
             */
        if(input.isKeyPressed(Input.KEY_X)){
                tiro = new TiroPersonagem(pos.x+sprite[status].getWidth()/2-4.5f, pos.y);
                tiros.add(tiro);
                shoot.play();
        }
        for(Iterator<TiroPersonagem> it = tiros.iterator(); it.hasNext();) {
            tiro = it.next();
            tiro.update(delta);
            if(tiro.getPos().y < (0-tiro.getHeight())) {
                it.remove();
            }
        }
    }
}